בסיעתא דשמיא. Algorithms. Yosef Zohar תוכן עניינים

Transcription

1 בסיעתא דשמיא - מימושים Algorithms Yosef Zohar בעיה 1 בעיה 2 א' בעיה 2 ב' בעיה 3 בעיה 4 בעיה 5 בעיה 6 בעיה 7 בעיה 8 בעיה 9 בעיה 11 בעיה 11 א' בעיה 11 ב' בעיה 12 הערות: תוכן עניינים בעיית החניה 1 בעיית 3 למבחן: מימושים ג'+ד' בעיית 4 בעיית האיבר הגדול מהחציון 9 בעיית הפיצה 9 משחק המספרים האופטימאלי 11 בעיית המזכירה 12 חישוב רקורסיבי בסיבוכיות נמוכה: 12 מספר בחזקת מספר מספר פיבונאצ'י בעיית 13 בעיית 14 בעיית הסופגניות 15 בעיית המטוס - מסלול בודד מינימאלי 16 בעיית המטוס - החזרת כל המסלולים המינימאליים ברקורסיה 17 בעיית שלושת הציידים 18 מימוש של אלגוריתמים אותם למדנו במהלך הסמסטר. חשוב לשים לב, האלגוריתמים מומשו כלימוד למבחן, ולכן לא בטוח שהם נכונים במאה אחוז. בהצלחה!!!!

2 1 בעיה מס' 1: בעיית החניה תיאור הבעיה: ישנו מגרש חניה בצורת מעגל, על החניה מופקד רובוט שסופר את המכוניות. רובוט זה בעל כמה תכונות: הוא יכול ללכת אחורה וקדימה, לסמן סימן ולספור מכוניות. החיסרון ברובוט: הוא אינו יודע מתי הוא התחיל את הספירה ומתוך כך הוא אינו יודע מתי היא מסתיימת, וזאת משום שהסיבוב שלו מעגלי. כיצד ניתן לדעת כמה מכוניות חונות במעגל עצמו בלבד? מספר דגשים: א. אין יציאה וכניסה של מכוניות למגרש בעת הספירה של הרובוט. ב. חשוב לשים לב לבעיה שייתכן כי הסימן אותו מסמן הרובוט - כבר קיים על אחת המכוניות במגרש, ולכן לא ניתן להניח שהסימן של הרובוט הוא בלעדי. מבנה המימוש: המימוש יעשה בעזרת מימוש של לינק-ליסט מעגלי, כאשר הרובוט מתחיל מנקודה כלשהי על המעגל - הוא "מסמן" את נקודת ההתחלה בסימן מסוים, ומתחיל לספור מכוניות, כאשר הוא נתקל באותו סימן - הוא מסמן אותו בסימן קבוע אחר - וסופר אחורה אם הוא מגיע לסימון החדש באותו מספר צעדים - הרי שזוהי נקודת ההתחלה - אחרת, הוא מתחיל שוב וסופר מנקודת ההתחלה, אלא שהפעם הוא לא יעצר בנקודה החשודה, משום שהיא נפסלה כבר. public class Node { Node next; Node prev; int data; מימוש בשפת מכונה: public Node(int d) { data = d; next = null; prev = null; public class List { Node head; Node tail; public List() { tail = null; head = tail; public void add(int a) { if (head==null) { head = new Node(a); head.next = head; head.prev = head; tail = head; else { Node n = new Node(a); n.next = head; n.prev = tail; head.prev = n; tail.next = n; tail = tail.next;

3 2 א. ב. public class parking { public static void main(string[] args) { // v = 1, x = 0 List l = new List(); int len = 0; הכנסת משתנים שונים // l.add(3); l.add(0); l.add(1); סימון נקודת ההתחלה בספרה // 1 1; = l.head.data Node temp = l.head.next; boolean ans = false; while (!ans) { int count = 1; while (temp.data!= 1) { count++; temp = temp.next; איפוס הנקודה שנמצאה חשודה כתחילת הסיבוב // ;0 = temp.data משתנה עזר לשמירת הספירה האחרונה // count; len = חזרה אחורה - לפי מספר הצעדים בהלוך while (count>0) { // temp = temp.prev; count--; אם מספר הצעדים זהה וגם הנקודה היא // 0 true; if (temp.data==0) ans = אחרת - מתחילים שוב, ז"א: לא הגענו עדיין להתחלה // temp.next; else temp = System.out.println("the num of cars is: " + len); בעיה מס' 1 -ב': בעיית חניה משודרגת תיאור הבעיה: ישנו מגרש חניה בצורת מעגל, על החניה מופקדים שני רובוטים שסופרים את המכוניות. רובוטים אלו בעלי כמה תכונות: הם יכולים ללכת אחורה וקדימה, לסמן סימן ולספור מכוניות. החיסרון ברובוטים: הם אינם יודעים מתי הם התחילו את הספירה ומתוך כך הם אינם יודעים מתי היא מסתיימת, וזאת משום שהסיבוב שלהם מעגלי. מעבר לכך: נקודת ההתחלה של שניהם לא על המעגל, אלא מבחוץ )אפשר לצייר את זה כמעין כביש גישה שגם שם חונות מכוניות(, כך שהם אינם יודעים ממתי הם התחילו לספור מכוניות שבתוך המעגל. כיצד ניתן לדעת כמה מכוניות חונות במעגל עצמו בלבד? מספר דגשים: אין יציאה וכניסה של מכוניות למגרש בעת הספירה של הרובוטים. חשוב לשים לב לבעיה שייתכן כי הסימן אותו מסמן הרובוט - כבר קיים על אחת המכוניות במגרש, ולכן לא ניתן להניח שהסימן של הרובוט הוא בלעדי. מבנה המימוש: המימוש יעשה בעזרת מימוש של לינק-ליסט מעגלי, כאשר אל הלינק ליסט המעגלי יהיה מקושר ללינק ליסט שאינו מעגלי המייצג את כביש הגישה. את הרובוטים יש להזניק מאותה נקודה, אך קצב ההתקדמות יהיה שונה, כאשר הראשון יספור בדילוגים, כך שמתישהו הם יפגשו באותה נקודה, כאשר זה יתרחש - הם יאפסו את הספירות, ישנו כיוון ויספרו מחדש, במפגש הבא שלהם הם ישלימו סיבוב ומספר המכוניות במעגל שווה לסכום הספירות. מימוש בשפת מכונה: חסר! לא מימשנו במהלך השיעור, ואיני יודע אם יש לממש אותו, לכן אני שומר זאת לסוף.

4 3 בעיה מס' 2 )באופן כללי( מציאת האיבר הגדול ביותר במערך בסיבוכיות ובמספר פעולות השוואה מינימאלי תיאור הבעיה: באופן הפשוט ביותר - ניתן לרוץ על איברי כל המערך ולמצוא את האיבר הגדול ביותר, אך כיצד נוכל לחסוך בזמן ריצה )מספר פעולות השוואה נמוך ביותר(, בנוסף: כיצד נפתור את הבעיה כאשר אנו מתבקשים למצוא את 2 האיברים הגדולים ביותר במערך. חשוב לשים לב, גם באופן הפשוט ביותר - יש צורך להוכיח באינדוקציה: כיצד ניתן להוכיח כי אם נחפש בכל המערך את האיבר הגדול ביותר ע"י השוואה - באמת נקבל את האיבר הגדול ביותר?, ז"א: כאשר ישנו רק איבר אחד במערך - בוודאי הוא המקסימאלי. בסיס האינדוקציה:,. הנחת האינדוקציה: הנוסחה נכונה עבור הקטן מסך האיברים : ) ( (. צריך להוכיח: )) ( (., צריך להוכיח: ) ( הוכחה: נסמן ) (, לכן לפי תכונה של טרנזיטיביות:, מכאן נובע כי: מקרה א':. נובע כי. מ.ש.ל. ולפי הנחת האינדוקציה יוצא כי:, אזי מקרה ב': בעיה מס' 2 -א': מציאת איבר קטן ביותר ואיבר גדול ביותר - במספר פעולות השוואה מינימאלי תיאור הבעיה: נתחיל ונאמר כי הסיבוכיות תהיה ) ( משום שאנחנו צריכים לרוץ על כל איברי המערך, אך כיצד ניתן יהיה לשפר את מספר הפעולות למינימאלי. מימוש בשפת מכונה: נביא תחילה מימוש של החיפוש הרגיל, מספר הפעולות יהיה פי 2 מגודל המערך )ז"א: ) ( (: public static int MaxAndMin_Original(int arr[]) { int max = arr[0]; int min = arr[0]; int countofstep = 0; ריצה על כל המערך באופן הפשוט ביותר // { (++i for (int ;1=i i<arr.length; if (arr[i]>max) max = arr[i]; if (arr[i]<min) min = arr[i]; return countofstep; כעת, נביא מימוש שמספר הפעולות יהיה פי אחד וחצי בלבד ולא פי 2 )ז"א: ) ( :) public static int MaxAndMin_LessStep(int arr[]) { int max = arr[0]; int min = arr[0]; int countofstep = 0; ריצה על חצי המערך, בדילוג של // 2 { i=i+2) for (int i=1; i<arr.length-1; if (arr[i]>arr[i+1]) { countofstep = countofstep + 2; if (arr[i]>max) max = arr[i]; if (arr[i+1]<min) min = arr[i+1]; בדיוק אותה השוואה, רק כאן האיבר השני גדול מהראשון // { else countofstep = countofstep + 2; if (arr[i+1]>max) max = arr[i+1]; if (arr[i]<min) min = arr[i]; return countofstep;

5 4 ג. ד. בעיה מס' 2 -ב': מציאת שני איברים הגדולים ביותר במערך - במספר פעולות השוואה מינימאלי תיאור הבעיה: כנ"ל. מספר דגשים: א. כל איברי המערך שונים זה מזה ב. מניחים כי במערך יש לכל הפחות 2 איברים מימוש בשפת מכונה: נקדים ונאמר שישנם כמה סוגי מימושים: א. מימוש רגיל בריצה על כל איברי המערך )מספר פעולות השוואה: ) ( (. ב. מימוש בריצה על חצי המערך, משום שבכל פעם מתקדמים ב- 2 איברים )מספר פעולות השוואה: ) (.) פעולות, אך במקרה של מערך ממויין - אכן חשוב לשים לב: בדרך כלל מערך ראנדומאלי ייקח קרוב ל- ) (. ( הסיבוכיות תהיה ) נקודה נוספת: הגיוני שבמבחן ישאלו דווקא על ג' או ד', משום ש:א' ו-ב' בעלי סיבוכיות גבוהה. ( ), כשבכל אובייקט יש מחסנית, באופן אינדוקטיבי. (( ( מימוש בעזרת אובייקט ) ( ), כשבכל אובייקט יש מחסנית, באופן רקורסיבי. (( ( מימוש בעזרת אובייקט ) מימוש א': מימוש של החיפוש הרגיל, מספר הפעולות יהיה פי 2 מגודל המערך )ז"א: ) ( (: public static int max1max2_original(int arr[]) { int countofstep = 0; int max1 = arr[0]; int max2 = arr[1]; מציאת האיבר הגדול והקטן ממנו מבין שני האיברים הראשונים במערך // { (max2>max1) if int tempmax = max1; max1 = max2; max2 = tempmax; for (int i=2; i<arr.length; i++) { if (arr[i]>max1) { max2 = max1; max1 = arr[i]; else { if (arr[i]>max2) max2 = arr[i]; System.out.println("max1 is: "+max1); System.out.println("max2 is: "+max2); return countofstep;

6 5 :) מימוש ב': מימוש החיפוש כך שמספר הפעולות יהיה פי אחד וחצי בלבד ולא פי 2 )ז"א: ) ( public static int max1max2_lessstep(int arr[]) { int max1 = arr[0]; int max2 = arr[1]; int countofstep = 1; if (max2>max1) { int tempmax = max1; max1 = max2; max2 = tempmax; ריצה על חצי המערך // { i=i+2) for (int i=2; i<arr.length-1; if (arr[i]>arr[i+1]) { if (arr[i]>max2) { if (arr[i]>max1) { max2 = max1; max1 = arr[i]; else max2 = arr[i]; בדיוק אותה השוואה, רק כאן האיבר השני גדול מהראשון // { else if (arr[i+1]>max2) { if (arr[i+1]>max1) { max2 = max1; max1 = arr[i+1]; else max2 = arr[i+1]; בדיקת מקרה קיצון - מערך שאינו זוגי // { (arr.length%2!=0) if if (arr[arr.length-1]>max2) { if (arr[arr.length-1]>max1) { max2 = max1; max1 = arr[arr.length-1]; else max2 = arr[arr.length-1]; return countofstep;

7 6 מימוש ג': מימוש בעזרת אובייקט ) ), באופן אינדוקטיבי, מספר פעולות השוואה: (( ( ( אופן המימוש: לשם המימוש נבנה רשימה מקושרת מעגלית, ופונקציה המעבירה איברים ממערך רנדומאלי לרשימה המקושרת. כך שבכל אובייקט יהיה את האיבר, המייצג את האיבר הגדול ביותר באותו אובייקט )הנתון שהתקבל מתוך המערך(, וכן מחסנית. בכל פעם נשווה בין 2 איברים ברשימה, אם האחד גדול מחברו - האיבר הקטן יותר ייכנס לתוך המחסנית של האיבר הגדול יותר, והאיבר הקטן יימחק מהרשימה, הוא וכל האובייקט שלו, עד שבסופו של דבר יישאר אובייקט אחד - שהאיבר הוא הערך הגבוה ביותר במערך, וכל מה שנותר זה לחפש מהו האיבר השני בגודלו - שאת זה נעשה ע"י מציאת האיבר הגדול ביותר במחסנית. import java.util.stack; public class StackNodeCircle { StackNodeCircle next; StackNodeCircle prev; נכנס לתוך משתנה העצם הזה: // max1; int Stack <Integer> stackofnode; מימוש מחלקת : הערך של האיבר מהמערך - ניתן היה לבנות כאן בנאי ברירת מחדל, אך ניתן להסתדר גם אם בנאי בודד // public StackNodeCircle(int data, StackNodeCircle n, StackNodeCircle p){ max1 = data; next = n; prev = p; הצהרה על מחסנית חדשה // Stack<Integer>(); stackofnode = new מימוש הפונקציות עצמן: public class findmax1max2_withstack { פונקציית עזר - הכנסת איברים מתוך מערך לרשימה מקושרת מעגלית )ממומשת ) // public static StackNodeCircle initalize(int arr[]) { StackNodeCircle head = new StackNodeCircle(arr[0],null,null); int size = arr.length; StackNodeCircle tempnode = head; נוד נוסף - לקבלת האיבר העוקב // null; StackNodeCircle nownode = לולאה להכנסת כל האיברים לרשימה אחת // { i++) for (int i=1; i<size; nownode = new StackNodeCircle(arr[i],tempNode,null); tempnode.next = nownode; nownode.prev = tempnode; tempnode = tempnode.next; הפיכת הרשימה לרשימה מעגלית nownode.next = head; // head.prev = nownode; return head; public static void Max1Max2_withStack() { קריאה לפונקציה היוצרת מערך רנדומאלי // randarr(100); int arr[] = int size = arr.length; StackNodeCircle init = initalize(arr); printnode(init); StackNodeCircle tempnode1 = init; StackNodeCircle tempnode2 = null;

8 7 טמפ 2 הוא העוקב של טמפ 1 while (size>1) { tempnode2 = tempnode1.next; // if (tempnode1.max1>tempnode2.max1) { כאשר הראשון גדול מהשני מתבצעות ארבע פעולות // tempnode1.stackofnode.push(tempnode2.max1); tempnode1.next = tempnode2.next; tempnode2.next.prev = tempnode1; tempnode1 = tempnode1.next; else { כאשר השני גדול מהראשון מתבצעות חמש פעולות // tempnode2.stackofnode.push(tempnode1.max1); tempnode2.prev = tempnode1.prev; tempnode1.prev.next = tempnode2; tempnode1 = tempnode2.next; tempnode2 = tempnode2.next; size--; System.out.println("max1 = "+tempnode1.max1); באופן שרירותי מגדירים את האיבר הראשון כגדול ביותר במחסנית, ובהמשך בודקים זאת // int max2 = tempnode1.stackofnode.pop(); int tempmax2; while (tempnode1.stackofnode.isempty()==false) { tempmax2 = tempnode1.stackofnode.pop(); if (tempmax2>max2) max2 = tempmax2; System.out.println("max2 = "+max2); מימוש ד': מימוש בעזרת אובייקט ) ), כשבכל אובייקט יש מחסנית, באופן רקורסיבי. (( ( (. אופן המימוש: לשם המימוש נבנה מערך של אובייקטים, ופונקציה המעבירה איברים ממערך רנדומאלי למערך של, כך שבכל אובייקט יהיה את האיבר, המייצג את האיבר הגדול ביותר באותו אובייקט )הנתון, כאשר אנחנו בעצם שהתקבל מתוך המערך(, וכן מחסנית. כעת נפעיל על המערך החדש מעין חיפוש של "מפרקים" באופן רקורסיבי את המערך עד לקבלת השוואה בין כל איבר בודד. כעת נשווה בין 2 איברים ברשימה, אם האחד גדול מחברו - האיבר הקטן יותר ייכנס לתוך המחסנית של האיבר הגדול יותר, ויוחזר המיקום של הערך הגדול יותר, עד שבסופו של דבר יוחזר אובייקט אחד - שהאיבר הוא הערך הגבוה ביותר במערך, וכל מה שנותר זה לחפש מהו האיבר השני בגודלו - שאת זה נעשה ע"י מציאת האיבר הגדול ביותר במחסנית. ( ). הוכחה באינדוקציה: )לא הבנתי אותה, אני רק משכתב( בסיס:. נוסחת נסיגה: הנחה: הוכחה:, צריך להוכיח:

9 8 מימוש מחלקת : import java.util.stack; public class StackNode { int max1; Stack <Integer> stackofnode; חשוב לשים לב שכאן אין לנו מצביעים לאיבר הבא ולאיבר הקודם, משום שהמימוש יעשה ע"י מערך של נודים // public StackNode(int data){ max1 = data; stackofnode = new Stack<Integer>(); מימוש הפונקציות עצמן: public class findmax1max2_withstack_reko { public static StackNode[] initalize(int arr[]) { int size = arr.length; יצירת מערך של אובייקטים // StackNode[size]; StackNode Nodes[] = new for (int i=0; i<size; i++) Nodes[i] = new StackNode(arr[i]); return Nodes; public static int Max1Max2_withStack_Reko(StackNode Nodes[], int low, int high){ int mid; if (low<high) { mid = (low+high)/2; פעולת הרקורסיה תתרחש עד שנגיע למצב בו כל איבר עומד בנפרד // int i = Max1Max2_withStack_Reko(Nodes,low,mid); int j = Max1Max2_withStack_Reko(Nodes,mid+1,high); if (Nodes[i].max1>Nodes[j].max1) { Nodes[i].stackOfNode.push(Nodes[j].max1); בעצם מחזירים את האינדקס של האובייקט הגדול // ;i return else { Nodes[j].stackOfNode.push(Nodes[i].max1); כנ"ל // j; return זהו האינדקס של האובייקט בעל הערך הגדול ביותר בסופו של התהליך // low; return public static void Max1Max2_withStack_Reko(){ קריאה לפונקציה היוצרת מערך רנדומאלי // randarr(100); int arr[] = int size = arr.length; StackNode Nodes[] = initalize(arr); int ans = Max1Max2_withStack_Reko(Nodes,0,size-1); System.out.println("max1 is: " + Nodes[ans].max1); int max2 = Nodes[ans].stackOfNode.pop(); int tempmax2; while (Nodes[ans].stackOfNode.isEmpty()==false) { tempmax2 = Nodes[ans].stackOfNode.pop(); if (tempmax2>max2) max2 = tempmax2; System.out.println("max2 is: " + max2);

10 9 בעיה מס' 3: מציאת איבר גדול מהחציון במערך של מספרים, בסיבוכיות קטנה ככל האפשר תיאור הבעיה: נתון מערך, כיצד ניתן למצוא מספר הגדול מהחציון תוך שימוש בסיבוכיות נמוכה ביותר? באופן הפשוט היה אפשר לסדר את המערך לפי סדר ולהחזיר את האיבר במקום ה"אמצע פלוס אחד", אך זה כמובן לא יעיל, גם שיטה האומרת לסדר "חצי מערך פלוס אחד" ולהחזיר את האיבר האחרון - אינה יעילה, השיטה שתוצג להלן נכונה כמעט ב- זהו מספר האיברים שבמערך, ולכן ככל שהמערך גדול, כאשר 111 אחוז, וניתן לסמוך על זה )הסיכוי לטעות הוא: יותר הסיכוי לטעות הוא אפסי יותר(. מספר דגשים: כפי שהובא לעיל, הפתרון הוא "חמדני" ולכן ישנו אחוז אפסי של טעות. א. המימוש יעשה ע"י בדיקה של 64 איברים ראשונים בלבד! )במהלך השיעור הראתה אליזבט שככל שעולים ב. במספר האיברים - הסיכוי לטעות הולך וקטן(, ולכן במימוש עצמו ניתן לחלק - מערך שקטן מ- 128 איברים - אפשר לסדר "חצי פלוס אחד", גדול מ- 128 איברים - עדיף לעבוד בשיטה החמדנית. מימוש בשפת מכונה: הנכונה. שים לב, במימוש הובאה האפשרות הראשונה והלא יעילה, רק לשם בדיקה והשוואה לתשובה import java.util.arrays; public class findhalfplusinarr { פונקציה זו לא נצרכת למימוש אלא להשוואה בלבד // public static int mediansort(int arr[]){ Arrays.sort(arr); int Emtza = arr.length/2; return arr[emtza]; public static int median64(int arr[]) { int max = arr[0]; מציאת האיבר הגדול מתוך 46 איברים ראשונים // { i++) for (int i=1; i<64; if (arr[i]>max) max = arr[i]; return max; בעיה מס' 4 ב: עיית הפיצה תיאור הבעיה: שני חברים יושבים לאכול פיצה, הראשון אוכל במהירות פי x יותר גבוהה מחברו. כיצד נחתוך את הפיצה בשביל שהראשון יאכל כמות מקסימאלית של משולשים? דגש חשוב: אסור להגיע למצב בו שני החברים מסיימים לאכול ונותר משולש בודד. אופן המימוש: המימוש עצמו מאוד פשוט, וזאת לאחר שיודעים את הנוסחא )וכפי שיובא לקמן בשפת המכונה(, עיקר הקושי בשאלה זו - להוכיח שאכן חיתוך שכזה ייתן מספר משולשים מקסימאלי לאכלן המהיר. public static int cutpizza(double x) { if (x ==(int) x) return (int)x + 1; else return (int)x + 2;

11 11 בעיה מס' 5: משחק המספרים תיאור הבעיה: משחק זה מיועד לשני שחקנים, מחשב מול סטודנט או מחשב מול מחשב, כאשר נתון מערך של מספרים, וכל אחד בתורו לוקח מספר - מתחילת המערך או מסופו. המנצח - מי שסכום המספרים שלו גבוה יותר. יש צורך לבנות אלגוריתם שיגרום לשחקן הראשון לנצח תמיד. משימה זו מתחלקת לשניים: א. ניצחון כלשהו, או תיקו, העיקר שהשחקן הראשון לא יפסיד - לא בחומר. ב. ניצחון ברמה הכי טובה שאפשר )אופטימאלי( מספר דגשים: 1. ניתן להניח כי המערך הוא זוגי 2. ניתן להניח כי המחשב )השחקן הראשון( תמיד מתחיל. 3. המימוש להלן - מחשב מול מחשב. אופן המימוש: public class NumberGame_Optimal { int arr[];// int size; שפת מכונה: בנאי // { Arr[]) public NumberGame_Optimal(int size = Arr.length; arr = new int[size]; for (int i=0; i<size; i++) { arr[i] = Arr[i]; יצירת מטריצה ומילויה ע "פ הנוסחא שנלמדה בשיעור // { getmartix() public int[][] int mat[][] = new int [size][size]; for (int i=0; i<size; i++) { mat[i][i] = arr[i]; מילוי המשולש העליון של המטריצה // { j++) for (int j=1; j<size; for (int i=0; i<size-j; i++) { int x = arr[i] - mat[i+1][i+j]; int y = arr[i+j] - mat[i][i+j-1]; mat[i][i+j] = Math.max(x, y); return mat; פונקציה לחישוב המשחק האופטימאלי // { playyourbest() public int int mat[][] = getmartix(); int i = 0 ; int j = size-1; האינדקסים של לקיחת הקלפים // 0; = second int first = 0, int sumfirst = 0, sumsecond = 0;

12 11 for (int t=0; t<(size/2); t++) { השחקן הראשון לוקח קלף // if (arr[i] - mat[i+1][j] > arr[j] - mat[i][j-1]) { sumfirst = sumfirst + arr[i]; הקלף הראשון עדיף - לכן הוא נלקח // ;i first = המערך "מתקצר" מראשו // ;++i else { sumfirst = sumfirst + arr[j]; הקלף השני עדיף - לכן הוא נלקח // ;j first = המערך "מתקצר" מסופו // ;--j השחקן השני לוקח קלף - כל עוד יש יותר מאיבר אחד במערך // { (0<j) if החישוב אופטימאלי גם לשחקן השני, כמובן שהראשון עדיין ינצח // if (arr[i] - mat[i+1][j] > arr[j] - mat[i][j-1]) { sumsecond = sumsecond + arr[i]; second = i; i++; else { sumsecond = sumsecond + arr[j]; second = j; j--; נשאר רק קלף אחד - השחקן השני מחויב לקחת אותו // { else second = j; sumsecond = sumsecond + arr[j]; System.out.println("first take " + arr[first] + ", and second take " + arr[second]); סוף הלולאה // System.out.println(); System.out.println("firstSum = " + sumfirst + ", secondsum = "+sumsecond); return sumfirst;

13 12 בעיה מס' 6: בעיית המזכירה תיאור הבעיה: נתון מערך של מוזמנים לתור אצל הרופא, כל איבר במערך מציין את הזמן שלוקח למוזמן להיות אצל הרופא. כל המוזמנים מגיעים בבת אחת אל המרפאה. כיצד תסדר המזכירה את התורים באופן הטוב ביותר )שהמוזמנים יחכו כמה שפחות(. על המערך וכך הזמן הכולל של כל אחד יהיה נמוך ביותר. רק צריך לדעת להוכיח הפתרון הוא פשוט - יש לעשות, וכן הלאה. בעצם ניתן לומר, שכמובן כולל בתוכו את זמן. המוזמן השני לוקח - זאת. ההוכחה תעשה באופן הבא: נאמר כי המוזמן הראשון לוקח כך: ( ) ( ) ( ) ( ). נקבל תוצאה גדולה יותר, משום ש: ההוכחה תראה שכאשר נחליף בין בעיה מס' 7: חישוב רקורסיבי בסיבוכיות נמוכה: נעשה כאן 2 מימושים ושינהם בסיבוכיות ) ( : א. מספר בחזקת מספר ב. מספר פיבונאצ'י תיאור הבעיה: הפונקציה מקבלת 2 מספרים, וצריכה לחשב את החזקה שביניהם במינימום סיבוכיות. מימוש בשפת מכונה - א': public static double PowInLogN(int x, int n) { תנאי עצירה לרקורסיה // 1; if (n==0) return אם מדובר בחזקה זוגית // PowInLogN(x*x,n/2); else if (n%2==0) return אם מדובר בחזקה אי זוגית // x*powinlogn(x*x,(n-1)/2); else return מימוש בשפת מכונה - ב': לפני המימוש עצמו, נסביר את מבנה המימוש: בשביל להגיע למספר פיבונאצ'י יש להכפיל את המטריצה פעמים, התוצאה במיקום ] ][ [ זהו הערך של המספר הפיבונצא'י לפי האינדקס שהפונקציה קיבלה. ( ) הפונקציה הראשית כפי שהוסבר לעיל // { index) public static int whatfibo(int int mat[][] = {{1,1,{1,0; int ans[][] = fiboreko(mat,index-1); return ans[0][0]; public static int[][] fiboreko(int mat[][], int index) { תנאי עצירה - הכפלה במטריצה int flag[][] = {{1,0,{0,1; // I if (index==0) return flag; else if (index%2==0) return fiboreko(kefelmatrix(mat,mat),index/2); else return KefelMatrix(mat,fiboReko(KefelMatrix(mat,mat),(index-1)/2)); פונקציית עזר לחישוב כפל של מטריצה 2 על 2 כפול מטריצה 2 על // 2 public static int[][] KefelMatrix(int mat1[][], int mat2[][]) { int matans[][] = new int[2][2]; matans[0][0] = mat1[0][0]*mat2[0][0] + mat1[0][1]*mat2[1][0]; matans[0][1] = mat1[0][0]*mat2[0][1] + mat1[0][1]*mat2[1][1]; matans[1][0] = mat1[1][0]*mat2[0][0] + mat1[1][1]*mat2[1][0]; matans[1][1] = mat1[1][0]*mat2[0][1] + mat1[1][1]*mat2[1][1]; return matans; חשוב לשים לב: את הפונקציות הנ"ל ניתן לממש באופן אינדוקטיבי כאשר הסיבוכיות נשמרת.

14 13 בעיה מס' 8: :LCS תיאור הבעיה: בהרבה תחומים יש צורך להגיע מרצף של אותות למילה בעלת משמעות. אלא שבתוך הרצף עלולים להיכנס גם טעויות, ולכן אנחנו נדרשים ב: LCS לנסות ולבודד את האותות הקרובים ביותר לדבר הנכון. דוגמא לכך: חיפוש בגוגל עם שגיאה: כגון: "חסאה", האלגוריתם יתן את המילה ל"חסה", ז"א: האות א' מיותרת. וזאת משום שהאלגוריתם השווה בין מאגר של מילים )כגון מילון( לבין רצף האותות ומצא מהי המילה הדומה ביותר. מספר דגשים: א. ההתאמה הכי טובה - הרצף הארוך ביותר. ב. חשוב לשים לב שב: LCS אנחנו לא עובדים על תיקון של ג. במהלך השיעור הראנו כי חיפוש שלם לא יעיל, ואלגוריתם חמדני יביא לטעויות רבות, לכן מבנה המימוש יעשה בעזרת בניה של מטריצה כפי שיוסבר להלן. מבנה המימוש: תחילה עלינו לבנות מטריצה, כשאורך המטריצה הוא אורך המילה הראשונה+ 1, ורוחב המטריצה זהו אורך המילה השניה+ 1. לאחר מכן נמלא את השורה והה הראשונות במספרים )1,1( אם יש שוויון או שאין שוויון בהתאמה. לאחר מכן - בכל משבצת במטריצה נעשה השוואה בין 2 אותיות - אם האותיות זהות - נכניס בתוך אותו מיקום את הערך של המספר באלכסון מלמעלה פלוס אחד, אם האותיות אינן שוות, נבחר את המספר המקסימאלי מבין השנים - מלמעלה או מצד שמאל. לאחר מילוי המטריצה נוכל לדעת מהו אורך המילה הארוכה ביותר, וזאת ע"י האינדקס האחרון של המטריצה. בנוסף: נוכל כעת לחזור אחורה במסלול ולגלות מהי המילה הדומה ביותר. וראה מימוש בשפת מכונה: פונקציית עזר המייצרת מערך דו מימדי של אפסים עם שורה וה נוספת // public static int[][] getcleanmatrix(string ones, String twos) { int one = ones.length()+1; int two = twos.length()+1; int matans[][] = new int [one][two]; return matans; public static int[][] fillmatrix(string ones, String twos) { int mat[][] = getcleanmatrix(ones,twos); for (int i=1; i<mat.length; i++) { for (int j=1; j<mat[0].length; j++) { if (ones.charat(i-1)==twos.charat(j-1)) { mat[i][j] = mat[i-1][j-1]+1; else mat[i][j] = Math.max(mat[i][j-1], mat[i-1][j]); return mat; פונקציה שמקבלת את המטריצה המלאה ומחזירה את הסטרינג הכי ארוך )מתוך כמה( // public static String goback(int mat[][], String ones, String twos) { int i = mat.length-1; int j = mat[0].length-1; int max = mat[i][j]; int start = 0; String ans = ""; while (start<max) { if (ones.charat(i-1)==twos.charat(j-1)) { כאשר האיברים דומים המימוש הוא בחירה שרירותית ולכן נקבל תשובה נכונה מתוך כמה... // ans = ones.charat(i-1) + ans; // ans = twos.charat(j-1) + ans; i--;

15 14 j--; start++; else { if (mat[i-1][j]>=mat[i][j-1]) i--; else j--; return ans; בעיה מס' 9: :LIS תיאור הבעיה: למצוא במערך של מספרים את הרצף הארוך ביותר. מבנה המימוש: ניתן לממש את הפתרון בשתי דרכים: )שניהם בסיבוכיות של ) ( ) א. בעזרת,LCS כאשר יוצרים העתק למערך, עושים להעתק,Sort ומפעילים.LCS ב. בעזרת תכנות דינאמי במימוש של א' - נעתיק את הפונקציות של LCS ונשנה את המשתנים מ- String ל- Int. )לא העתקתי לכאן את המימוש( מימוש של ב' - נבנה מטריצה ריבועית בגדול המערך, כאשר האיבר הראשון במערך הוא גם האיבר הראשון במטריצה. כעת נעבור לבדוק את האיבר הבא במערך, אם הוא קטן מהאיבר הראשון - הוא יחליף את האיבר הראשון במטריצה, אם הוא גדול מכל האיברים באותה השורה - הוא יכנס בסוף השורה, אם הוא בין לבין - נשתמש בחיפוש בינארי - כאשר אם האיבר ימצא - לא נעשה דבר, אם הוא לי ימצא - יוחזר האינדקס המתאים לו. מימוש בשפת מכונה: פונקציית עזר למציאת האינדקס המתאים לאיבר מהמערך בתוך המשולש העליון של המטריצה // public static int search(int mat[][], int endline, int val) { אם האיבר קטן מהראשון - הוא הראשון // ;0 if (val<mat[0][0]) return אם האיבר המוכנס גדול יותר מהאיבר האחרון שבאותה שורה - האינדקס שיוחזר - איבר אחד נוסף // if (val>=mat[endline-1][endline-1]) return endline; אפשרות אחרונה - האיבר המוכנס נמצא באמצע האלכסון - ולכן נשתמש בחיפוש בינארי // int low = 0; int high = endline-1; while (low<=high) { int mid = (low+high)/2; if (low==high) { האיבר לא נמצא באלכסון, ולכן יוחזר האינדקס המתאים // low; return else { האיבר נמצא // mid; if (mat[mid][mid]==val) return if (val<mat[mid][mid]) high = mid; else low = mid+1; החזרת ערך ברירת מחדל // ;1- return פונקציית עזר להעתקת הערכים משורה לשורה במטריצה עד האיבר האחרון )לא כולל( // public static void copy (int mat[][], int i) { for (int j=0; j<i; j++) mat[i][j] = mat[i-1][j];

16 15 public static int[] getlis(int Arr[]) { int size = Arr.length; בניית מטריצה ריבועית בגודל המערך // int[size][size]; int mat[][] = new כרגע השורה הבאה היא // 1 1; = endline int int index; האיבר הראשון במטריצה הוא האיבר הראשון במערך // Arr[0]; mat[0][0] = for (int i=1; i<size; i++) { מציאת האינדקס // search(mat,endline,arr[i]); index = mat[index][index] = Arr[i]; העתקת השורה עד האינדקס // copy(mat,index); ירידת שורה כאשר סיימנו את השורה של המשולש // endline++; if (index>=endline) printmatrix(mat); העברת השורה הסופית לתוך מערך // int[endline]; int ans[] = new for (int i=0; i<endline; i++) { ans[i] = mat[endline-1][i]; return ans; בעיה מס' 10: בעיית הסופגניות: תיאור הבעיה: נתון מחבת ובו מקום מוגבל לטיגון סופגניות, וישנו מספר נתון של סופגניות, כל סופגניה מטגנת דקה אחת בכל צד, סה"כ 2 דק'. מהו הזמן המינימאלי לטיגון של x סופגניות בתוך מחבת בגודל n. מבנה המימוש: נשתמש בנוסחא שהגענו אליה בכיתה: מספר השלמים פחות אחד כפול )2 2 דקות( + 3 דקות, משום שאת השארית ניתן לטגן בפחות זמן, וזאת על פי השיטה הבאה: למשל, נשארו לנו 9 סופגניות לטגן במחבת בגודל של 6, אנחנו נעבוד באופן הבא: Time a b c d e f g h I 1 min min min מימוש בשפת מכונה: public static int gettime(int numofsuf, int numofplace) { int temptime = 0; מספר הסופגניות קטן מגודל המחבת // ;2 if (numofplace>=numofsuf) return מספר הסופגניות מתחלק באופן שלם בגודל המחבת // (numofsuf%numofplace==0) if return (numofsuf/numofplace)*2; כמות השלמים // (numofsuf/numofplace)-1; int shalem = הזמן שלוקח לטגן את כל השלמים בתוספת 3 דק' כפי שהובא לעיל // ;3 shalem*2 + temptime = return temptime;

17 16 בעיה מס' 11 -א': בעיית המטוס - העברת נתונים למטריצה וחישוב עלות מינימאלית + מסלול בודד מינימאלי תיאור הבעיה: מקבלים כנתון גרף של נתונים, כך שיש להגיע מקדקוד שמאלי תחתון אל קדקוד עליון ימיני בדרך היעילה ביותר )עם פניות ימינה ולמעלה בלבד(, כאשר כל צלע בעלת עלות שונה, ועלינו למצוא את אחד המסלולים הטובים ביותר וכן את מספר המסלולים הטובים ביותר )בעלי אותו ערך(. מבנה המימוש: את הגרף נכניס לתוך מטריצה של אובייקטים, כשבכל אובייקט יש שני אפשרויות להמשך המסלול, ועוד 2 פרמטרים: פרמטר הסוכם את העלות המינימאלית, ופרמטר הסוכם את כמות המסלולים האופטימאליים. הסיבוכיות של בניית מסלול אחד תהיה ) (, מעבר לכך יש סיבוכיות למילוי של המטריצה, שזה: ) (. לאחר מילוי המטריצה - נחשב את העליות של כל המסלולים. דבר זה יעשה ע"י הכנסת הערכים של השורה והה הראשונות בנתונים. לאחר מכאן - נבדוק בכל איבר במטריצה - מהו המסלול העדיף באופן דינאמי. מימוש מחלקת : public class NodeGraph { int x_right; int y_up; int minprice; int numoftracks; public NodeGraph(int x, int y) { x_right = x; y_up = y; minprice = 0; numoftracks = 0; מימוש הפונקציות עצמן: public static void fillnodemat(nodegraph mat[][]) { מילוי ה ראשונה // { i++) for (int i=1; i<mat.length; mat[i][0].minprice = mat[i-1][0].minprice + mat[i-1][0].y_up; mat[i][0].numoftracks = 1; מילוי שורה ראשונה // { j++) for (int j=1; j<mat[0].length; mat[0][j].minprice = mat[0][j-1].minprice + mat[0][j-1].x_right; mat[0][j].numoftracks = 1; for (int i=1; i<mat.length; i++) { for (int j=1; j<mat[0].length; j++) { int maybemin1 = mat[i][j-1].minprice+mat[i][j-1].x_right; int maybemin2 = mat[i-1][j].minprice+mat[i-1][j].y_up; if (maybemin1<maybemin2) { mat[i][j].minprice = maybemin1; mat[i][j].numoftracks = mat[i][j-1].numoftracks; if (maybemin1>maybemin2) { mat[i][j].minprice = maybemin2; mat[i][j].numoftracks = mat[i-1][j].numoftracks; if (maybemin1==maybemin2) { mat[i][j].minprice = maybemin1; mat[i][j].numoftracks = mat[i-1][j].numoftracks + mat[i][j-1].numoftracks;

18 17 פונקציה המחזירה את אחד מהמסלולים הטובים ביותר // public static String getonetrack(nodegraph mat[][]) { // right = 0, up = 1 String sans = ""; int i = mat.length-1; int j = mat[0].length-1; כל עוד שניהם מתקיימים // { j>0) while (i>0 && if (mat[i][j-1].minprice+mat[i][j-1].x_right <= mat[i-1][j].minprice+mat[i-1][j].y_up) { sans = "0" + sans; j--; else { sans = "1" + sans; i--; לולאות להשלמת האיברים החסרים // { t--) for (int t=i; t>0; sans = "1" + sans; for (int t=j; t>0; t--) { sans = "0" + sans; return sans; בעיה מס' 11 -ב': בעיית המטוס - חישוב כל המסלולים המינימאליים ברקורסיה תיאור הבעיה: בסעיף א' מצאנו מסלול אחד מתוך כמה מסלולים, כעת אנחנו נדרשים למצוא את כל המסלולים. חשוב לשים לב, כי גם כאן נצטרך לבנות בדיוק את אותה מטריצה ולמלאות אותה בדיוק באותו אופן, נוסיף כאן רק את הפונקציה הרקורסיבית: public static void getalltracks(nodegraph mat[][]) { Vector <String> alltracks = new Vector<String>(); getalltracksreko(new String(), mat.length-1, mat[0].length-1, alltracks, mat); System.out.println(allTracks); public static void getalltracksreko(string track, int i, int j, Vector alltracks, NodeGraph mat[][]){ if (i>0 && j>0) { int maybe1 = mat[i-1][j].minprice + mat[i-1][j].y_up; int maybe2 = mat[i][j-1].minprice + mat[i][j-1].x_right; המסלול הזול נבחר, וזהו מסלול יחידי, לכן ממשיכים באותה הדרך // (maybe1<maybe2) if getalltracksreko("1"+track,i-1,j,alltracks,mat); כנ"ל // (maybe1>maybe2) else if getalltracksreko("0"+track,i,j-1,alltracks,mat); כאן 2 האפשרויות נכונות, ולכן נבדוק את 2 המסלולים // { else getalltracksreko("1"+track,i-1,j,alltracks,mat); getalltracksreko("0"+new String(track),i,j-1,allTracks,mat);

19 18 אם הגענו לנק' ההתחלה - תכניס לתוך הווקטור // alltracks.add(track); if 0==i) & (0==j הגענו לקצה המטריצה מלמעלה למטה, אך מימין לשמאל עדיין לא // { (0==i) else if String temp = new String(); for (int t=i; t>=0; t--) temp = temp + "0"; alltracks.add(temp + track); הגענו לקצה המטריצה מימים לשמאל, אך מלמעלה למטה עדיין לא // { (0==j) else if String temp = new String(); for (int t=j; t>=0; t--) temp = temp + "1"; alltracks.add(temp + track); בעיה מס' 12: בעיית שלושת הציידים תיאור הבעיה: ישנם שלושה ציידים הנלחמים זה בזה, לצייד הראשון 111 אחוזי פגיעה, לצייד השני 81 אחוזי פגיעה, לצייד השלישי 51 אחוזי פגיעה. סדר השחקנים נקבע באופן רנדומאלי. כיצד ניתן לגרום לצייד החלש ביותר לנצח ביותר מ- 51 אחוז מהסבבים )לדוגמא - סבב של 111 משחקים( מבנה המימוש: מבנה זה אינו מכיל אובייקטים מסובכים, אלא הוא מאוד ארוך, משום שישנם הרבה מאוד מקרים שיש לכסות. תחילה, בשביל להחליט מי ראשון, מי שני ומי שלישי - נשתמש בפונקציית עזר - הקובעת את הסדר באופן רנדומאלי, לאחר מכן - נכסה את כל המקרים האפשריים )ע"פ חלוקה לשלושה מקרים - מי הראשון(. public class fightof3sniper { int count_hunt1; int count_hunt2; int count_hunt3; public fightof3sniper() { count_hunt1 = 0; count_hunt2 = 0; count_hunt3 = 0; פונקציית עזר לקביעת סדר היורים // { RanHunt() public static int[] int rand = (int) (Math.random()*6); int mat[][] = {{1,2,3,{1,3,2,{3,1,2,{3,2,1,{2,1,3,{2,3,1; return mat[rand]; public void shoot() { אחוזי פגיעה של צייד מס' // 2 0.8; = hunt2 double אחוזי פגיעה של צייד מס' // 3 0.5; = hunt3 double פרמטרים לחישוב מספר רנדומאלי // hunt2_chance; double double hunt3_chance; int A = 1; int B = 2; int C = 3; boolean flag = true; int rand[] = RanHunt(); int first = rand[0]; switch(first){ case 1: //hunt1 is first - kill hunt2 hunt3_chance = Math.random(); if (hunt3_chance<hunt3) count_hunt3++; // hunt3 kill hunt1; else count_hunt1++; // hunt1 kill hunt3 break;

20 19 case 2: // hunt2 is first, try to kill hunt1 hunt2_chance = Math.random(); if (hunt2_chance<hunt2) { // hunt2 kill hunt1, now hunt2 and hunt 3 fight flag = true; while (flag) { hunt3_chance = Math.random(); if (hunt3_chance<hunt3) { // hunt3 kill hunt2; count_hunt3++; flag = false; else { hunt2_chance = Math.random(); if (hunt2_chance<hunt2) {//hunt2 kill hunt3; count_hunt2++; flag = false; else // hunt2 didn't kill hunt1 if (rand[1]==a) { //hunt1 is second, and he kill hunt2 hunt3_chance = Math.random(); if (hunt3_chance<hunt3) count_hunt3++; // hunt3 kill hunt1; else count_hunt1++; // hunt1 kill hunt3 else if (rand[1]==c) { //hunt3 is 2, he dosn't fire, and hunt1 kill hunt2 hunt3_chance = Math.random(); if (hunt3_chance<hunt3) count_hunt3++; // hunt3 kill hunt1 else count_hunt1++; // hunt1 kill hunt3 break; case 3: // hunt3 is first, he dosn't fire if (rand[1]==a) { //hunt1 is second, and he kill hunt2 hunt3_chance = Math.random(); if (hunt3_chance<hunt3) count_hunt3++; // hunt3 kill hunt1; else count_hunt1++; // hunt1 kill hunt3 else if (rand[1]==b) { //hunt2 is second, and he kill hunt1 hunt2_chance = Math.random(); if (hunt2_chance<hunt2) { // hunt2 kill hunt1, now hunt2 and hunt 3 fight flag = true; while (flag) { hunt3_chance = Math.random(); if (hunt3_chance<hunt3) { // hunt3 kill hunt2;

21 21 break; count_hunt3++; flag = false; else { hunt2_chance = Math.random(); if (hunt2_chance<hunt2) { // hunt2 kill hunt3; count_hunt2++; flag = false; else { // hunt2 dosn't kill hunt1, hunt1 kill hunt2 hunt3_chance = Math.random(); if (hunt3_chance<hunt3) count_hunt3++; // hunt3 kill hunt1; else count_hunt1++; // hunt1 kill hunt3